import QtQuick 2.15
import QtQuick.Controls 2.15

Item {
    id: root
    
    property int animationNum: 12
    property bool animationRunning: false
    property real scaleFactor: 1.0
    
    // 存储所有动画项
    property var animationItems: []
    property bool itemsCreated: false
    
    function startAnimation() {
        if (animationRunning) return
        
        // 确保尺寸已初始化
        if (root.width <= 0 || root.height <= 0) {
            Qt.callLater(function() {
                if (root.width > 0 && root.height > 0) {
                    startAnimation()
                }
            })
            return
        }
        
        // 确保元素已创建
        if (!itemsCreated) {
            createAnimationItems()
        }
        
        animationRunning = true
        
        // 重置所有项（包括初始元素）
        resetAllItems()
        resetInitialItem()
        
        // 先移动初始元素
        Qt.callLater(function() {
            initialItem.startMove()
        })
    }
    
    function createAnimationItems() {
        if (itemsCreated) return
        
        // 确保尺寸已初始化
        if (root.width <= 0 || root.height <= 0) {
            Qt.callLater(function() {
                if (root.width > 0 && root.height > 0) {
                    createAnimationItems()
                }
            })
            return
        }
        
        var index = animationNum / 2
        for (var i = 0; i < animationNum; i++) {
            var item = animationItemComponent.createObject(root, {
                "itemIndex": i,
                "isSmall": i < index
            })
            if (item) {
                // 初始化位置到中心
                var centerX = (root.width - item.width) / 2
                var centerY = (root.height - item.height) / 2
                item.x = centerX
                item.y = centerY
                animationItems.push(item)
            }
        }
        itemsCreated = true
    }
    
    function resetAllItems() {
        // 重置所有弹出项
        for (var i = 0; i < animationItems.length; i++) {
            if (animationItems[i]) {
                animationItems[i].reset()
            }
        }
        // 重置初始元素
        if (root.width > 0 && root.height > 0) {
            initialItem.x = root.width - initialItem.width
            initialItem.y = root.height - initialItem.height
            initialItem.opacity = 1.0
            initialItem.visible = false
        }
        root.opacity = 1.0
    }
    
    function resetInitialItem() {
        // 重置初始元素的位置和透明度
        if (root.width > 0 && root.height > 0) {
            initialItem.x = root.width - initialItem.width
            initialItem.y = root.height - initialItem.height
            initialItem.opacity = 1.0
            initialItem.visible = true
        }
    }
    
    // 延迟创建动画元素，确保尺寸已初始化
    Component.onCompleted: {
        // 初始化 initialItem 的位置（如果尺寸已可用）
        if (root.width > 0 && root.height > 0) {
            initialItem.x = root.width - initialItem.width
            initialItem.y = root.height - initialItem.height
        }
        Qt.callLater(function() {
            createAnimationItems()
        })
    }
    
    // 监听尺寸变化，更新 initialItem 位置
    onWidthChanged: {
        if (width > 0 && height > 0 && !animationRunning) {
            initialItem.x = width - initialItem.width
            initialItem.y = height - initialItem.height
        }
    }
    
    onHeightChanged: {
        if (width > 0 && height > 0 && !animationRunning) {
            initialItem.x = width - initialItem.width
            initialItem.y = height - initialItem.height
        }
    }
    
    // 初始移动元素
    Image {
        id: initialItem
        width: 80 * scaleFactor
        height: 80 * scaleFactor
        // 不设置 x 和 y 绑定，在函数中手动设置位置
        source: "qrc:/animationTest/qrc/th-c1.png"
        fillMode: Image.PreserveAspectFit
        visible: false  // 初始隐藏，在 startMove 中显示
        
        ParallelAnimation {
            id: moveAnimation
            
            PropertyAnimation {
                id: moveXAnim
                target: initialItem
                property: "x"
                duration: 1000
            }
            
            PropertyAnimation {
                id: moveYAnim
                target: initialItem
                property: "y"
                duration: 1000
            }
            
            PropertyAnimation {
                id: moveOpacityAnim
                target: initialItem
                property: "opacity"
                from: 1.0
                to: 0.0
                duration: 1000
            }
            
            onFinished: {
                // 移动完成后，开始弹出动画
                root.startPopAnimation()
            }
        }
        
        function startMove() {
            // 确保尺寸已初始化
            if (root.width <= 0 || root.height <= 0) {
                // 延迟重试
                Qt.callLater(function() {
                    if (root.width > 0 && root.height > 0) {
                        startMove()
                    }
                })
                return
            }
            
            // 重置位置和透明度
            var startX = root.width - initialItem.width
            var startY = root.height - initialItem.height
            var endX = (root.width - initialItem.width) / 2
            var endY = (root.height - initialItem.height) / 2
            
            initialItem.x = startX
            initialItem.y = startY
            initialItem.opacity = 1.0
            initialItem.visible = true
            
            // 更新动画的起始值和结束值
            moveXAnim.from = startX
            moveXAnim.to = endX
            moveYAnim.from = startY
            moveYAnim.to = endY
            moveOpacityAnim.from = 1.0
            moveOpacityAnim.to = 0.0
            
            moveAnimation.start()
        }
    }
    
    function startPopAnimation() {
        // 显示所有元素（匹配原始逻辑：sltStartAnimationGroup）
        for (var i = 0; i < animationItems.length; i++) {
            if (animationItems[i]) {
                animationItems[i].visible = true
            }
        }
        
        // 设置所有元素的动画值并启动（匹配原始逻辑：changeAnimationValue）
        for (var i = 0; i < animationItems.length; i++) {
            if (animationItems[i]) {
                animationItems[i].startPopAnimation()
            }
        }
        
        // 开始整体淡出动画（匹配原始逻辑：sltStartAnimationOpacityEffect）
        // 注意：原始代码中整体淡出动画是添加到 m_animationGroup 中并行执行的
        // 这里我们单独启动，但时间点匹配：0.9之前保持1.0，然后600ms内淡出到0.0
        fadeOutAnimation.start()
    }
    
    // 整体淡出动画（匹配原始逻辑：sltStartAnimationOpacityEffect）
    // 原始代码：duration=1500, KeyValueAt(0, 1.0), KeyValueAt(0.9, 1.0), KeyValueAt(1, 0.0)
    // 这意味着：0-1350ms保持1.0，1350-1500ms淡出到0.0
    SequentialAnimation {
        id: fadeOutAnimation
        
        PauseAnimation {
            duration: 1350  // 0.9 * 1500 = 1350ms
        }
        
        PropertyAnimation {
            target: root
            property: "opacity"
            from: 1.0
            to: 0.0
            duration: 150  // 1500 - 1350 = 150ms
        }
        
        onFinished: {
            // 动画完成后重置
            root.opacity = 1.0
            root.animationRunning = false
            resetAllItems()
        }
    }
    
            Component {
        id: animationItemComponent
        
        Image {
            id: popItem
            property int itemIndex: 0
            property bool isSmall: false
            
            width: isSmall ? 60 * scaleFactor : 80 * scaleFactor
            height: width
            // 不设置 x 和 y 绑定，在函数中手动设置位置
            source: {
                var imgIndex = itemIndex + 1
                if (imgIndex > 13) imgIndex = 13  // 限制最大索引
                return "qrc:/animationTest/qrc/th-c" + imgIndex + ".png"
            }
            fillMode: Image.PreserveAspectFit
            visible: false
            
            function startPopAnimation() {
                // 确保 root 尺寸已初始化
                if (root.width <= 0 || root.height <= 0) {
                    return
                }
                
                // 重置到中心位置（匹配原始逻辑：changeAnimationValue）
                // 原始代码：descX = this->width() - size.width()
                //          startValue = QRect(descX / 2, descY / 2, size.width(), size.width())
                // 所以中心位置是：(width - itemWidth) / 2
                var centerX = (root.width - width) / 2
                var centerY = (root.height - height) / 2
                
                // 先停止之前的动画（如果有）
                popXAnimation.stop()
                popYAnimation.stop()
                
                // 设置当前位置为中心
                x = centerX
                y = centerY
                
                // 随机目标位置（防止控件越界）
                // 原始代码：posX = qrand() % descX, posY = qrand() % descY
                var descX = root.width - width
                var descY = root.height - height
                var targetX = Math.floor(Math.random() * Math.max(1, descX))
                var targetY = Math.floor(Math.random() * Math.max(1, descY))
                
                // 设置动画起始值和结束值（匹配原始逻辑）
                popXAnimation.from = centerX
                popXAnimation.to = targetX
                popYAnimation.from = centerY
                popYAnimation.to = targetY
                
                // 启动动画
                popXAnimation.start()
                popYAnimation.start()
            }
            
            function reset() {
                if (root.width > 0 && root.height > 0) {
                    x = (root.width - width) / 2
                    y = (root.height - height) / 2
                }
                visible = false
            }
            
            PropertyAnimation on x {
                id: popXAnimation
                duration: 1500
                easing.type: Easing.InQuad
                running: false
            }
            
            PropertyAnimation on y {
                id: popYAnimation
                duration: 1500
                easing.type: Easing.InQuad
                running: false
            }
        }
    }
}
